package com.satan.juc.demo24;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;

public class AtomicIntegerExample {
    public static void main(String[] args) {
        // 创建一个新的AtomicInteger，默认初始值为0
        AtomicInteger atomicInteger = new AtomicInteger();

        // 获取当前值
        int currentValue = atomicInteger.get();

        // 设置给定值
        atomicInteger.set(123);

        // 获取当前值，并设置新的值
        int oldValue = atomicInteger.getAndSet(456);

        // 如果当前值等于预期值，则以原子方式将该值设置为给定的更新值
        boolean wasUpdated = atomicInteger.compareAndSet(456, 789);

        // 以原子方式将给定值添加到当前值
        int newSum = atomicInteger.addAndGet(300);

        // 获取当前值，并以原子方式将给定值添加到它
        int previousValue = atomicInteger.getAndAdd(300);

        // 以原子方式递增当前值
        int incrementedValue = atomicInteger.incrementAndGet();

        // 获取当前值，并以原子方式递增
        int prevIncrementedValue = atomicInteger.getAndIncrement();

        // 以原子方式递减当前值
        int decrementedValue = atomicInteger.decrementAndGet();

        // 获取当前值，并以原子方式递减
        int prevDecrementedValue = atomicInteger.getAndDecrement();

        // 使用给定函数以原子方式更新当前值，并返回更新后的值
        IntUnaryOperator updateFunction = x -> x * 2;
        int updatedValue = atomicInteger.updateAndGet(updateFunction);

        // 获取当前值，并使用给定函数以原子方式更新它
        int prevUpdatedValue = atomicInteger.getAndUpdate(updateFunction);

        // 使用给定函数和给定值以原子方式累加当前值，并返回累加后的值
        IntBinaryOperator accumulatorFunction = (x, y) -> x + y;
        int accumulatedValue = atomicInteger.accumulateAndGet(500, accumulatorFunction);

        // 获取当前值，并使用给定函数和给定值以原子方式累加它
        int prevAccumulatedValue = atomicInteger.getAndAccumulate(500, accumulatorFunction);
    }
}
